/**
 * AZ翻译插件 - 后台脚本
 * @author huangguohui2002
 * @description 处理翻译请求的核心后台逻辑
 */

import { Translate } from "@/utils/api";

// 定义支持的AI模型类型
type ModelType = 'openai' | 'anthropic' | 'gemini' | 'ollama' | 'azure' | 'modelscope' | 'iflow' | 'custom';

// 定义响应解析器接口
interface ResponseParser {
  parseResponse(data: any): string;
}

// 创建不同模型的响应解析器
const responseParserMap: Record<ModelType, ResponseParser> = {
  openai: {
    parseResponse(data: any): string {
      // OpenAI格式响应解析
      return data.choices?.[0]?.message?.content || data.choices?.[0]?.text || '';
    }
  },
  anthropic: {
    parseResponse(data: any): string {
      // Anthropic Claude格式响应解析
      return data.content?.[0]?.text || '';
    }
  },
  gemini: {
    parseResponse(data: any): string {
      // Google Gemini格式响应解析
      return data.candidates?.[0]?.content?.parts?.[0]?.text || '';
    }
  },
  ollama: {
    parseResponse(data: any): string {
      // Ollama格式响应解析
      return data.response || '';
    }
  },
  azure: {
    parseResponse(data: any): string {
      // Azure OpenAI格式响应解析 (类似OpenAI)
      return data.choices?.[0]?.message?.content || '';
    }
  },
  modelscope: {
    parseResponse(data: any): string {
      // ModelScope格式响应解析
      return data.choices?.[0]?.message?.content || 
             data.output?.text || 
             data.response || 
             '';
    }
  },
  iflow: {
    parseResponse(data: any): string {
      // iflow.cn API格式响应解析
      return data.choices?.[0]?.message?.content || 
             data.output?.text || 
             data.response || 
             '';
    }
  },
  custom: {
    parseResponse(data: any): string {
      // 自定义格式，尝试多种可能的路径
      return data.text || data.content || data.result || data.translation || 
             data.response || data.output || data.message || 
             (data.choices?.[0]?.text) || (data.choices?.[0]?.message?.content) || 
             JSON.stringify(data);
    }
  }
};

export default defineBackground(async () => {
  // 监听消息 - 注意异步处理
  browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
      // 处理异步操作，返回true告知浏览器等待异步响应
      myBackgroundFunction(message).then(result => {
        console.log('发送翻译结果回内容脚本:', result);
        sendResponse(result);
      }).catch(error => {
        // 错误处理
        console.error('翻译错误:', error);
        sendResponse({ error: error.message || '翻译过程中发生未知错误' });
      });
      return true; // 关键：保持消息通道开放等待异步响应
  });

  // 异步处理函数
  async function myBackgroundFunction(message: any) {
    try {
      const { text, apiConfig } = message;
      
      // 确保apiConfig包含必要的字段
      if (!apiConfig || !apiConfig.apiAddress) {
        throw new Error('API配置不完整，请检查apiAddress字段');
      }
      
      // 根据URL自动识别模型类型
      if (!apiConfig.modelType && apiConfig.apiAddress) {
        if (apiConfig.apiAddress.includes('modelscope')) {
          apiConfig.modelType = 'modelscope';
        } else if (apiConfig.apiAddress.includes('iflow.cn') || apiConfig.apiAddress.includes('apis.iflow')) {
          apiConfig.modelType = 'iflow';
        }
      }
      
      const result = Translate(message);
      
      console.log('发送请求到:', result.url);
      console.log('请求体:', JSON.stringify(result.payload));
      console.log('请求头:', result.headers);
      
      // 等待fetch完成
      const response = await fetch(result.url, {
        method: "POST",
        headers: result.headers,
        body: JSON.stringify(result.payload),
      });
      
      // 检查HTTP错误状态
      if (!response.ok) {
        const errorText = await response.text().catch(() => '');
        throw new Error(`API请求失败: ${response.status} ${response.statusText}\n${errorText}`);
      }
      
      const data = await response.json();
      console.log("翻译结果原始数据:", data);
      
      // 确定模型类型，默认为custom
      const modelType = (apiConfig.modelType || 'custom') as ModelType;
      
      // 使用对应的解析器解析响应
      const parser = responseParserMap[modelType];
      const translatedText = parser.parseResponse(data);
      
      if (!translatedText) {
        console.warn('解析后的翻译结果为空，原始响应:', data);
      }
      
      console.log("解析后的翻译结果:", translatedText);
      
      // 返回解析后的翻译结果
      return { translatedText };
    } catch (error) {
      console.error("翻译处理失败:", error);
      throw error; // 抛出错误让上层处理
    }
  }
});